{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:43.028266Z",
     "start_time": "2025-03-06T08:03:39.891178Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.3.1+cu121\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 数据准备",
   "id": "9aa9a7f619b58640"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:48.936902Z",
     "start_time": "2025-03-06T08:03:43.029272Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from tensorflow import keras\n",
    "\n",
    "# karas中的数据集imbd，电影评论分类\n",
    "imdb = keras.datasets.imdb\n",
    "\n",
    "# 载入数据\n",
    "# 词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "vocab_size = 10000\n",
    "\n",
    "# 序号从3开始，0,1,2,3空出来做别的事,作为特殊字符处理\n",
    "index_from = 3\n",
    "\n",
    "# 取出的词表是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words=vocab_size, index_from=index_from)"
   ],
   "id": "66f4d8b1e6cecc3e",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:48.941185Z",
     "start_time": "2025-03-06T08:03:48.936902Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"tpye of train_data:\", type(train_data))\n",
    "print(\"shape of train_data:\", train_data.shape)  # #每个样本是一段话，每个单词用一个数字表示\n",
    "print(\"type of train_labels:\", type(train_labels))\n",
    "print(\"shape of train_labels:\", train_labels.shape)"
   ],
   "id": "eae94708155fd5d3",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tpye of train_data: <class 'numpy.ndarray'>\n",
      "shape of train_data: (25000,)\n",
      "type of train_labels: <class 'numpy.ndarray'>\n",
      "shape of train_labels: (25000,)\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:48.977293Z",
     "start_time": "2025-03-06T08:03:48.941185Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "# 加载IMDB词典，将其转换为字典形式\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "# 词表有八万多单词，只加载前10000个单词"
   ],
   "id": "f0c9a1ead904f140",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 构造 word2idx 和 idx2word",
   "id": "1e44cea8a5be4e97"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:48.999806Z",
     "start_time": "2025-03-06T08:03:48.977293Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 词典，单词到id的映射，作用：将文本转换为数字序列\n",
    "word2idx = {word: (idx + 3) for word, idx in word_index.items()}\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,  # 填充token\n",
    "    \"[BOS]\": 1,  # 句子开始\n",
    "    \"[UNK]\": 2,  # 未知token\n",
    "    \"[EOS]\": 3,  # 句子结束\n",
    "})\n",
    "\n",
    "# 反向词典，id变为单词，作用：将模型输出的id转换为单词\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}"
   ],
   "id": "a9ad2364a4321d28",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:49.468764Z",
     "start_time": "2025-03-06T08:03:49.000905Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 构造句子长度统计图\n",
    "length_collect = {}\n",
    "#统计样本中每个长度出现的次数\n",
    "for text in train_data:\n",
    "    # 单个句子的长度\n",
    "    length = len(text)\n",
    "\n",
    "    # 统计长度的频率\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1\n",
    "\n",
    "MAX_LENGTH = 500\n",
    "# 长度分布图\n",
    "plt.bar(length_collect.keys(), length_collect.values())\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "id": "fd4205f1eeed8f05",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# Tokenizer",
   "id": "649403acc462cd50"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:49.475016Z",
     "start_time": "2025-03-06T08:03:49.468764Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class Tokenizer:\n",
    "\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx  #词表,单词到id\n",
    "        self.idx2word = idx2word  #词表，id到单词\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx  #填充\n",
    "        self.bos_idx = bos_idx  #开始\n",
    "        self.eos_idx = eos_idx  #结束\n",
    "        self.unk_idx = unk_idx  #未知，未出现在最高频词表中的词\n",
    "\n",
    "    def encode(self, text_list, padding_first=False):\n",
    "        \"\"\"\n",
    "        将文本列表转化为索引列表\n",
    "        :param text_list:当前批次的文本列表\n",
    "        :param padding_first:是否padding加载前面\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        # 最大长度，句子长度小于500，取句子长度，大于500，取500，一个批次内的最大长度\n",
    "        max_length = min(self.max_length, 2 + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "\n",
    "            #直接切片取前max_length-2个单词，然后加上bos和eos\n",
    "            indices = [self.bos_idx] + [self.word2idx.get(word, self.unk_idx) for word in text[:max_length - 2]] + [\n",
    "                self.eos_idx]\n",
    "            if padding_first:\n",
    "                # 填充0\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices\n",
    "            else:\n",
    "                # 如果padding_first == False，则padding加载后面\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        return torch.tensor(indices_list)  #二维列表转化为tensor\n",
    "\n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        \"\"\"\n",
    "        将索引列表转化为文本列表\n",
    "        :param indices_list:某批次的索引列表\n",
    "        :param remove_bos:移除开始符\n",
    "        :param remove_eos:移除结束符\n",
    "        :param remove_pad:移除填充符\n",
    "        :param split:分词\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        # 生成文本列表\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            # 单词列表\n",
    "            text = []\n",
    "\n",
    "            # 循环遍历索引列表\n",
    "            for index in indices:\n",
    "\n",
    "                # id转化为单词\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                # 移除开始符\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                # 移除结束符\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                # 移除填充符\n",
    "                if remove_pad and word == \"ruptedException\":\n",
    "                    break\n",
    "                # 添加单词到文本列表\n",
    "                text.append(word)\n",
    "            # 合并单词列表为句子\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list"
   ],
   "id": "159e0f16f1c84c7d",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:49.480498Z",
     "start_time": "2025-03-06T08:03:49.475016Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#测试Tokenizer\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text, padding_first=True)  #encode支持批量处理\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)\n",
    "\n",
    "# 解码,保留特殊符号\n",
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"decode text----------\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ],
   "id": "c42bb6a8aeba8b79",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw text\n",
      "['hello', 'world']\n",
      "['tokenize', 'text', 'datas', 'with', 'batch']\n",
      "['this', 'is', 'a', 'test']\n",
      "indices\n",
      "tensor([   0,    0,    0,    1, 4825,  182,    3])\n",
      "tensor([    1,     2,  3004,     2,    19, 19233,     3])\n",
      "tensor([   0,    1,   14,    9,    6, 2181,    3])\n",
      "decode text----------\n",
      "[PAD] [PAD] [PAD] [BOS] hello world [EOS]\n",
      "[BOS] [UNK] text [UNK] with batch [EOS]\n",
      "[PAD] [BOS] this is a test [EOS]\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 数据集与DataLoader",
   "id": "751b550e741757aa"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:50.305684Z",
     "start_time": "2025-03-06T08:03:49.480498Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:  #字符串输出样本中，是否含有【BOS】和【EOS】，【PAD】\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 去除【BOS】和【EOS】，【PAD】\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "\n",
    "def collate_fct(batch):\n",
    "    \"\"\"\n",
    "    将batch数据处理成tensor形式\n",
    "    :param batch:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    # 文本列表，批次中每个样本的文本分词[[],[],[]]\n",
    "    text_list = [item[0].split() for item in batch]\n",
    "    # 标签列表\n",
    "    label_list = [item[1] for item in batch]\n",
    "    # 文本列表转化为索引列表\n",
    "    # 使用padding_first=True\n",
    "    text_list = tokenizer.encode(text_list, padding_first=True).to(dtype=torch.int)\n",
    "\n",
    "    # 标签列表转化为tensor,reshape(-1,1)是为了适配线性层的输入\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "train_ds = IMDBDataset(train_data, train_labels)\n",
    "test_ds = IMDBDataset(test_data, test_labels)"
   ],
   "id": "d2da4c3b2e95c28d",
   "outputs": [],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:50.309695Z",
     "start_time": "2025-03-06T08:03:50.305684Z"
    }
   },
   "cell_type": "code",
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)  #collate_fn是处理batch的函数\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ],
   "id": "4c4be00d9ea2696b",
   "outputs": [],
   "execution_count": 10
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 模型定义",
   "id": "f964134fdba7a53f"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:50.314378Z",
     "start_time": "2025-03-06T08:03:50.309695Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class RNN(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size, num_layers=1, bidirectional=False):\n",
    "        \"\"\"\n",
    "        :param embedding_dim: 词向量维度\n",
    "        :param hidden_dim: 隐藏层维度\n",
    "        :param vocab_size: 词表大小\n",
    "        :param num_layers: 层数\n",
    "        :param bidirectional: 是否双向\n",
    "        \"\"\"\n",
    "        super(RNN, self).__init__()\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)\n",
    "\n",
    "        # RNN层,\n",
    "        # 输入维度是embedding_dim,输出维度是hidden_dim,num_layers是层数,batch_first=True表示输入和输出的第一个维度是batch_size\n",
    "        # bidirectional=True表示双向\n",
    "        self.rnn = nn.RNN(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True,\n",
    "                          bidirectional=bidirectional)\n",
    "        # 全连接层,输入维度是hidden_dim*2(双向)或hidden_dim(单向),输出维度是1\n",
    "        self.layer = nn.Linear(hidden_dim * (2 if bidirectional else 1), hidden_dim)\n",
    "        self.fc = nn.Linear(hidden_dim, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # [bs, seq length] -> [bs, seq length, embedding_dim]\n",
    "        x = self.embeding(x)\n",
    "\n",
    "        # [bs, seq length, embedding_dim] -> shape [bs, embedding_dim, seq length]\n",
    "        seq_output, final_hidden = self.rnn(x)\n",
    "\n",
    "        # [bs,seq length,hidden_dim] ->[*,bs,hidden_dim]\n",
    "        x = seq_output[:, -1, :]  # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)\n",
    "        return x"
   ],
   "id": "e4d440f720fc1f6e",
   "outputs": [],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:50.320656Z",
     "start_time": "2025-03-06T08:03:50.315383Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 模型结构参数\n",
    "print(\"{:=^80}\".format(\" 一层单向 RNN \"))\n",
    "for key, value in RNN().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "id": "333b5b3d15f433c8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================== 一层单向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:50.327321Z",
     "start_time": "2025-03-06T08:03:50.321661Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"{:=^80}\".format(\" 一层双向 RNN \"))\n",
    "for key, value in RNN(bidirectional=True).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "\n",
    "print(\"{:=^80}\".format(\" 俩层单向 RNN \"))\n",
    "for key, value in RNN(num_layers=2).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "id": "566c59efdb98ef8e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================== 一层双向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "        rnn.weight_ih_l0_reverse        paramerters num: 1024\n",
      "        rnn.weight_hh_l0_reverse        paramerters num: 4096\n",
      "         rnn.bias_ih_l0_reverse         paramerters num: 64\n",
      "         rnn.bias_hh_l0_reverse         paramerters num: 64\n",
      "              layer.weight              paramerters num: 8192\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n",
      "=================================== 俩层单向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "            rnn.weight_ih_l1            paramerters num: 4096\n",
      "            rnn.weight_hh_l1            paramerters num: 4096\n",
      "             rnn.bias_ih_l1             paramerters num: 64\n",
      "             rnn.bias_hh_l1             paramerters num: 64\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 模型训练",
   "id": "6944bd6b2c18311"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:50.370816Z",
     "start_time": "2025-03-06T08:03:50.328326Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "id": "5217abca94bfff3c",
   "outputs": [],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:50.375150Z",
     "start_time": "2025-03-06T08:03:50.370816Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "id": "55611881a84a4cdc",
   "outputs": [],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:50.379361Z",
     "start_time": "2025-03-06T08:03:50.375150Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else:\n",
    "            self.counter += 1\n",
    "\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "id": "bd7c7fd60cc27a9",
   "outputs": [],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:03:50.385281Z",
     "start_time": "2025-03-06T08:03:50.380365Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0\n",
    "\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 2. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "\n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict"
   ],
   "id": "f635a756ba6d5253",
   "outputs": [],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:06:43.031315Z",
     "start_time": "2025-03-06T08:03:50.386286Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 20\n",
    "\n",
    "# model = RNN(bidirectional=True) #双向单层\n",
    "model = RNN(num_layers=2)  # 单向双层\n",
    "# model = RNN()\n",
    "# 1. 定义损失函数 采用交叉熵损失 (但是二分类)\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-rnn\", save_step=len(train_dl), save_best_only=True)\n",
    "# 2. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_dl,\n",
    "    test_dl,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    ")"
   ],
   "id": "a05279ad58e8e2d3",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/3920 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "8c427c7fd1b84ceea76ff42cb77c7a17"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:06:43.180691Z",
     "start_time": "2025-03-06T08:06:43.032824Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ],
   "id": "b4a9323cf97d4383",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:06:46.518510Z",
     "start_time": "2025-03-06T08:06:43.180691Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-rnn/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "id": "501f090b4eea2ad9",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.5495\n",
      "accuracy: 0.7418\n"
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:06:46.521487Z",
     "start_time": "2025-03-06T08:06:46.519013Z"
    }
   },
   "cell_type": "code",
   "source": "",
   "id": "ae8f424b8072ff07",
   "outputs": [],
   "execution_count": 20
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
